#ifndef MESSAGE_H_
#define MESSAGE_H_

#include "../src/casual_includes.h"
#include "./logger.h"
/**
 * msg correspond aux données qui transitent sur le réseau interboursier. Ces données sont nommés
 * <i>messages</i> dans le sujet du projet.
 */
typedef struct msg_struct {
	/** l'identifiant de l'émetteur de l'ordre ;*/
	char emetteur[12];
	/** Type du message: 'Achat' 'Vente' 'AccuseVente' 'AccuseAchat'*/
	char type[12];
	/** l'identificateur de l'action sur laquelle porte l'ordre ou l'accusé */
	char action[11];
	/** valeur de l'ordre ou de l'accusé*/
	char valeur[6];
} msg;

/** 
 * create_msg: Construction du message. Le message est alloué dans la fonction.
 * @param *emetteur émetteur du message
 * @param *type type du message
 * @param *action identificateur de l'action
 * @param *valeur valeur associée au message
 * @return le message de type msg
 * <br><b>Exemple d'utilisation</b> <br> <tt>msg* ordre = create_msg(emetteur,type,action,valeur);</tt>
 */
msg* create_msg(const char *emetteur, const char *type, const char *action,
		const char *valeur);

/**
 * Decoupe d'un message: prend un message en char* et en extrait les informations
 * @param *message le texte du message
 * @param *emetteur émeteur du message
 * @param *type type du message
 * @param *action identificateur de l'action
 * @param *valeur valeur associée au message 
 * @return 0 si erreur, 1 sinon
 * ATTENTION: Les paramètres étant des pointeurs, les variables associées DOIVENT être allouées avant l'appel de la fonction
 * <br><b>Exemple d'utilisation</b> <br>
 <pre>char *emetteur, *type, *action, *valeur;
 emetteur=(char*)malloc(sizeof(char)*12);
 type=(char*)malloc(sizeof(char)*12);
 action=(char*)malloc(sizeof(char)*11);
 valeur=(char*)malloc(sizeof(char)*6);
 decoupe(mess,emetteur,type,action,valeur);</pre>
 */

int decoupe(char *message, char *emetteur, char *type, char *action,
		char *valeur);
/**
 * Transforme le message msg en une chaine de caractères suivant le protocole utilisé
 * Fait appel à message(). Si le programme est lancé en mode débug, alors cette opération est logguée.
 * @param msg le message de type msg à être transformé en char*
 * <br><b>Exemple d'utilisation</b> <br> <tt>char* rtn = msg_to_str(ordre_sous_forme_msg);</tt>
 */
char* msg_to_str(msg *msg);

/**
 * Transforme le message msg en une chaine de caractères suivant le protocole utilisé
 * Fait appel à decoupe(). Il n'est pas nécessaire d'allouer de la mémoire, celle-ci étant allouée dans la fonction.
 * @param mess le message de type char* à être transformé en msg*
 * <br><b>Exemple d'utilisation</b> <br> <tt>msg * rtn; rtn = str_to_msg("|0000000004|Vente|0003000003|39|");</tt>
 */
msg* str_to_msg(char* mess);

/** 
 * message: Construction du message. Le message est alloué dans la fonction.
 * @param *emeteur émeteur du message
 * @param *type type du message
 * @param *action identificateur de l'action
 * @param *valeur valeur associée au message
 * @return le message construit suivant le protocole à partir des arguments
 * <br><b>Exemple d'utilisation</b> <tt>message(msg->emetteur, msg->type, msg->action, msg->valeur)</tt>
 */
char* message(char *emeteur, char *type, char *action, char *valeur);

/**
 * Permet de logguer les ordres de transaction. Placé dans message.h puisque
 * utilisé uniquement pour les messages.
 * @param un_msg message d'explication lié à l'ordre de transaction 
 * @param damsg l'ordre à être loggué.
 * <br><b>Exemple d'utilisation</b> <tt>log_msg("Test du log de message",ordre);</tt><br>
 * Exemple de sortie: <tt>[M] <2009-01-10 02:43:56>  Test du log de message: Vente par 0000000004: action=0003000003 valeur=39 </tt>
 */
void log_msg(const char *un_msg, msg *damsg);

#endif // MESSAGE_H_
